home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / swtools / gencall / genctest.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-02  |  5.9 KB  |  306 lines
  1. /*
  2.  * genctest.c
  3.  *
  4.  *  test i/f for gencall.s and gencif.c
  5.  */
  6.  
  7.  
  8. #include "gencall.h"
  9. #include <math.h>
  10.  
  11.  
  12.  
  13. static int    args[] = {
  14.     { (int) "Arg1=%d Arg2=%s Arg3=%d Arg4=%s \n" },
  15.     { 5 },
  16.     { (int) "This is arg2" },
  17.     { 6 },
  18.     { (int) "This is arg4" },
  19. };
  20.  
  21. double weird_FFII( float a, float b, int i, int j )
  22. {
  23.     printf( "weird_FFII %f %f %d %d\n", a, b, i, j );
  24.     return a;
  25. }
  26.  
  27. double weird_DFI( double a, float b, int i )
  28. {
  29.     printf( "weird_DFI %f %f %d\n", a, b, i );
  30.     return a;
  31. }
  32.  
  33. main()
  34. {
  35.     extern int        printf();
  36.     extern void *   memcpy();
  37.  
  38.     double        dret;
  39.     double        darg;
  40.  
  41.     float        farg;
  42.     float        fret;
  43.  
  44.     float        faarg[ 5 ];
  45.     
  46.     CallFromGeneralArgs(
  47.     memcpy,
  48.     args,
  49.     sizeof( args ),
  50.     0,
  51.     0,
  52.     printf
  53.     );
  54.  
  55.     darg = 144.0;
  56.  
  57.     CallFromGeneralArgs(
  58.     memcpy,
  59.     & darg,
  60.     sizeof( darg ),
  61.     RETDOUBLE | FP_PASS_D,
  62.     &dret,
  63.     sqrt
  64.     );
  65.  
  66.     printf( "Sqrt of %f is %f\n", darg, dret );
  67.  
  68.     farg = 81.0;
  69.  
  70.     CallFromGeneralArgs(
  71.     memcpy,
  72.     & farg,
  73.     sizeof( farg ),
  74.     RETFLOAT | FP_PASS_F,
  75.     &fret,
  76.     sqrtf
  77.     );
  78.     
  79.     printf( "Sqrt of %f is %f\n", farg, fret );
  80.  
  81.     faarg[ 0 ] = 5.0;
  82.     faarg[ 1 ] = 144.0;
  83.  
  84.     * ( int * )( faarg + 2 ) = 55;
  85.     * ( int * )( faarg + 3 ) = 67;
  86.     
  87.     CallFromGeneralArgs(
  88.     memcpy,
  89.     & faarg,
  90.     sizeof( faarg ),
  91.     FP_PASS_F_F | RETDOUBLE,
  92.     &dret,
  93.     weird_FFII
  94.     );
  95.  
  96.     printf( "weird_FFII returns %f\n", dret );
  97.  
  98.     * ( double * )( faarg + 0 ) = 555.3;
  99.     faarg[ 2 ] = 144.0;
  100.     * ( int * )( faarg + 3 ) = 99;
  101.     
  102.     CallFromGeneralArgs(
  103.     memcpy,
  104.     & faarg,
  105.     sizeof( faarg ),
  106.     FP_PASS_D_F | RETDOUBLE,
  107.     &dret,
  108.     weird_DFI
  109.     );
  110.  
  111.     printf( "weird_DFI returns %f\n", dret );
  112.  
  113.  
  114.     ciftest();
  115. }
  116.  
  117.  
  118. #define ARYNI( ARRAY )    ARRAY, ( sizeof ARRAY )/( sizeof * ARRAY )
  119.  
  120. GCIF_ARG    gargs[] = {
  121.     gcif_double,    /* GCIF_ETYPE    gcif_type : 8;            */
  122.     8,            /* unsigned        gcif_align : 8;            */
  123.     8,            /* unsigned        gcif_size : 16;            */
  124. };
  125.  
  126. void          * argv[] = {
  127.     ( void * ) 0,
  128. };
  129.  
  130. GCIF_CALLDESC    cd[1] = {
  131.     /* GCIF_ARG          * gcif_args;    * args                */
  132.     /* unsigned        gcif_nargs;    * number of args        */
  133.     ARYNI( gargs ),
  134.  
  135.     gcif_double,    /* GCIF_ETYPE            gcif_rettype;        */
  136.     sizeof( double ),    /* unsigned        gcif_retsize;        */
  137.     
  138.     8,            /* unsigned        gcif_bytes;        */
  139.     GCIF_MKFLAGS( gcif_double, FP_PASS( gcif_double, gcif_void ) ),
  140.             /* unsigned        gcif_flags;        */
  141.  
  142.     /* void         ** gcif_argv;    * arg value pointers        */
  143.     /* int        gcif_nargv;    * number of value pointers    */
  144.     ARYNI( argv ),
  145.  
  146.     /* void          * gcif_retv;    * Return value            */    
  147. };
  148.  
  149. GCIF_ARG    zargs[] = {
  150. {
  151.     gcif_double,    /* GCIF_ETYPE    gcif_type : 8;            */
  152.     8,            /* unsigned        gcif_align : 8;            */
  153.     8,            /* unsigned        gcif_size : 16;            */
  154. },
  155. {
  156.     gcif_float,        /* GCIF_ETYPE    gcif_type : 8;            */
  157.     4,            /* unsigned        gcif_align : 8;            */
  158.     4,            /* unsigned        gcif_size : 16;            */
  159. },
  160. {
  161.     gcif_int,        /* GCIF_ETYPE    gcif_type : 8;            */
  162.     4,            /* unsigned        gcif_align : 8;            */
  163.     4,            /* unsigned        gcif_size : 16;            */
  164. },
  165. };
  166.  
  167. void          * zargv[] = {
  168.     ( void * ) 0,
  169.     ( void * ) 0,
  170.     ( void * ) 0,
  171. };
  172.  
  173. GCIF_CALLDESC    zcd[1] = {
  174.     /* GCIF_ARG          * gcif_args;    * args                */
  175.     /* unsigned        gcif_nargs;    * number of args        */
  176.     ARYNI( zargs ),
  177.  
  178.     gcif_double,    /* GCIF_ETYPE            gcif_rettype;        */
  179.     sizeof( double ),    /* unsigned        gcif_retsize;        */
  180.     
  181.     0,            /* unsigned        gcif_bytes;        */
  182.     0,
  183.     /* GCIF_MKFLAGS( gcif_double, FP_PASS( gcif_double, gcif_float ) ), */
  184.             /* unsigned        gcif_flags;        */
  185.  
  186.     /* void         ** gcif_argv;    * arg value pointers        */
  187.     /* int        gcif_nargv;    * number of value pointers    */
  188.     ARYNI( zargv ),
  189.  
  190.     /* void          * gcif_retv;    * Return value            */    
  191. };
  192.  
  193. ciftest()
  194. {
  195.     double        retval;
  196.     float        arg2;
  197.     int            i;
  198.     
  199.     cd->gcif_retv = ( void * ) & retval;
  200.  
  201.     argv[ 0 ] = ( void * ) & retval;
  202.  
  203.     retval = 121.0;
  204.  
  205.     gcif_call( sqrt, cd );
  206.  
  207.     printf( "sqrt of 121 is %f\n", retval );
  208.  
  209.     gcif_filldesc( zcd );
  210.     zcd->gcif_retv = ( void * ) & retval;
  211.  
  212.     zargv[ 0 ] = ( void * ) & retval;
  213.     zargv[ 1 ] = ( void * ) & arg2;
  214.     zargv[ 2 ] = ( void * ) & i;
  215.  
  216.     retval = 55.4;
  217.     arg2 = 44.3;
  218.     i = 77;
  219.  
  220.     gcif_call( weird_DFI, zcd );
  221.  
  222.     printf( "weird_DFI returns %f\n", retval );
  223.  
  224. }
  225.  
  226. /* structure passing example                        */
  227.  
  228. typedef struct {
  229.     char    val[23];
  230. } as;
  231.  
  232. GCIF_ARG    sargs[] = {
  233. {
  234.     gcif_struct,    /* GCIF_ETYPE    gcif_type : 8;            */
  235.     4,            /* unsigned        gcif_align : 8;            */
  236.     sizeof(as),        /* unsigned        gcif_size : 16;            */
  237. },
  238. {
  239.     gcif_float,        /* GCIF_ETYPE    gcif_type : 8;            */
  240.     4,            /* unsigned        gcif_align : 8;            */
  241.     4,            /* unsigned        gcif_size : 16;            */
  242. },
  243. {
  244.     gcif_int,        /* GCIF_ETYPE    gcif_type : 8;            */
  245.     4,            /* unsigned        gcif_align : 8;            */
  246.     4,            /* unsigned        gcif_size : 16;            */
  247. },
  248. };
  249.  
  250. void          * sargv[] = {
  251.     ( void * ) 0,
  252.     ( void * ) 0,
  253.     ( void * ) 0,
  254. };
  255.  
  256. GCIF_CALLDESC    scd[1] = {
  257.     /* GCIF_ARG          * gcif_args;    * args                */
  258.     /* unsigned        gcif_nargs;    * number of args        */
  259.     ARYNI( sargs ),
  260.  
  261.     gcif_struct,    /* GCIF_ETYPE            gcif_rettype;        */
  262.     sizeof( as ),    /* unsigned        gcif_retsize;        */
  263.     
  264.     0,            /* unsigned        gcif_bytes;        */
  265.     0,
  266.     /* GCIF_MKFLAGS( gcif_double, FP_PASS( gcif_double, gcif_float ) ), */
  267.             /* unsigned        gcif_flags;        */
  268.  
  269.     /* void         ** gcif_argv;    * arg value pointers        */
  270.     /* int        gcif_nargv;    * number of value pointers    */
  271.     ARYNI( sargv ),
  272.  
  273.     /* void          * gcif_retv;    * Return value            */    
  274. };
  275.  
  276. as as_SFI( as a, float b, int i )
  277. {
  278.     printf( "as_SFI %s %f %d\n", a.val, b, i );
  279.     return a;
  280. }
  281.  
  282. example_struct()
  283. {
  284.     double        retval;
  285.     float        arg2;
  286.     int            i;
  287.     as            s;
  288.     as            s1;
  289.     
  290.     gcif_filldesc( scd );
  291.     scd->gcif_retv = ( void * ) & s1;
  292.  
  293.     sargv[ 0 ] = ( void * ) & s;
  294.     sargv[ 1 ] = ( void * ) & arg2;
  295.     sargv[ 2 ] = ( void * ) & i;
  296.  
  297.     strcpy( s.val, "Hello world" );
  298.     arg2 = 122.7;
  299.     i = 29;
  300.  
  301.     gcif_call( as_SFI, scd );
  302.  
  303.     printf( "as_SFI returns %s\n", s1.val );
  304. }
  305.  
  306.